module Main (Main.main) where

import Graphics.UI.Gtk
import Yan

main = do
	initGUI
	
	window <- windowNew
	table1 <- tableNew 17 5 True
	table2 <- tableNew 17 5 True
	vBox1 <- vBoxNew False 0
	hBox1 <- hBoxNew False 0
	hBoxControll <- hBoxNew False 0
	hBoxHiddenControll <- hBoxNew False 0
	vJogador1 <- vBoxNew False 0
	vJogador2 <- vBoxNew False 0
	hTotal1 <- hBoxNew False 0
	hTotal2 <- hBoxNew False 0
	
	-- Menu
	mnuBar <- createMenuBar (menuBarDescr vJogador1 vJogador2 table1 table2 hBoxControll hBoxHiddenControll)
	containerAdd vBox1 mnuBar
	
	-- Botão New
	--btnNew <- createButtonContainer vBox1
	--buttonSetLabel btnNew "Novo"
	
	containerAdd vBox1 hBox1
	containerAdd vBox1 hBoxControll
	containerAdd vBox1 hBoxHiddenControll
	containerAdd hBox1 vJogador1
	containerAdd hBox1 vJogador2
	containerAdd vJogador1 table1
	containerAdd vJogador1 hTotal1
	containerAdd vJogador2 table2
	containerAdd vJogador2 hTotal2
	
	boxSetChildPacking vBox1 hBoxHiddenControll PackNatural 0 PackStart
	boxSetChildPacking vBox1 mnuBar PackNatural 0 PackStart
	boxSetChildPacking vBox1 hBoxControll PackNatural 0 PackStart
	widgetSetSizeRequest hBoxControll (-1) 90
	widgetSetSizeRequest hBoxHiddenControll (-1) 0
	
	 
	-- Tabela 1
	lblJogador1 <- createLabel table1 0 0 "Jogador1"
	lblSubida1 <- createLabel table1 1 0 "↓"
	lblDescida1 <- createLabel table1 2 0 "↑"
	lblLivre1 <- createLabel table1 3 0 "L"
	lblSeco1 <- createLabel table1 4 0 "S"
	lblUm1 <- createLabel table1 0 1 "1 (≥ 2)"
	lblDois1 <- createLabel table1 0 2 "2 (≥ 4)"
	lblTres1 <- createLabel table1 0 3 "3 (≥ 9)"
	lblQuatro1 <- createLabel table1 0 4 "4 (≥ 12)"
	lblCinco1 <- createLabel table1 0 5 "5 (≥ 15)"
	lblSeis1 <- createLabel table1 0 6 "6 (≥ 18)"
	lblBonus1 <- createLabel table1 0 7 "Bonus"
	lblTotal11 <- createLabel table1 0 8 "Total 1"
	lblTrinca1 <- createLabel table1 0 9 "Trinca"
	lblQuadra1 <- createLabel table1 0 10 "Quadra"
	lblFull1 <- createLabel table1 0 11 "Full House"
	lblSeqMin1 <- createLabel table1 0 12 "Sequencia -"
	lblSeqMax1 <- createLabel table1 0 13 "Sequencia +"
	lblSorte1 <- createLabel table1 0 14 "Sorte"
	lblYAN1 <- createLabel table1 0 15 "YAN"
	lblTotal21 <- createLabel table1 0 16 "Total 2"
	
	lblTotal1 <- createLabelContainer hTotal1 "Total Geral"
	
	btnDescidaUm1 <- createButton vJogador1 1 1 hBoxControll hBoxHiddenControll
	btnDescidaDois1 <- createButton vJogador1 1 2 hBoxControll hBoxHiddenControll
	btnDescidaTres1 <- createButton vJogador1 1 3 hBoxControll hBoxHiddenControll
	btnDescidaQuatro1 <- createButton vJogador1 1 4 hBoxControll hBoxHiddenControll
	btnDescidaCinco1 <- createButton vJogador1 1 5 hBoxControll hBoxHiddenControll
	btnDescidaSeis1 <- createButton vJogador1 1 6 hBoxControll hBoxHiddenControll
	btnDescidaBonus1 <- createInsensitiveButton table1 1 7
	btnDescidaTotal11 <- createInsensitiveButton table1 1 8
	btnDescidaTrinca1 <- createButton vJogador1 1 9 hBoxControll hBoxHiddenControll
	btnDescidaQuadra1 <- createButton vJogador1 1 10 hBoxControll hBoxHiddenControll
	btnDescidaFull1 <- createButton vJogador1 1 11 hBoxControll hBoxHiddenControll
	btnDescidaSeqMin1 <- createButton vJogador1 1 12 hBoxControll hBoxHiddenControll
	btnDescidaSeqMax1 <- createButton vJogador1 1 13 hBoxControll hBoxHiddenControll
	btnDescidaSorte1 <- createButton vJogador1 1 14 hBoxControll hBoxHiddenControll
	btnDescidaYAN1 <- createButton vJogador1 1 15 hBoxControll hBoxHiddenControll
	btnDescidaTotal21 <- createInsensitiveButton table1 1 16
	
	btnSubidaUm1 <- createButton vJogador1 2 1 hBoxControll hBoxHiddenControll
	btnSubidaDois1 <- createButton vJogador1 2 2 hBoxControll hBoxHiddenControll
	btnSubidaTres1 <- createButton vJogador1 2 3 hBoxControll hBoxHiddenControll
	btnSubidaQuatro1 <- createButton vJogador1 2 4 hBoxControll hBoxHiddenControll
	btnSubidaCinco1 <- createButton vJogador1 2 5 hBoxControll hBoxHiddenControll
	btnSubidaSeis1 <- createButton vJogador1 2 6 hBoxControll hBoxHiddenControll
	btnSubidaBonus1 <- createInsensitiveButton table1 2 7
	btnSubidaTotal11 <- createInsensitiveButton table1 2 8
	btnSubidaTrinca1 <- createButton vJogador1 2 9 hBoxControll hBoxHiddenControll
	btnSubidaQuadra1 <- createButton vJogador1 2 10 hBoxControll hBoxHiddenControll
	btnSubidaFull1 <- createButton vJogador1 2 11 hBoxControll hBoxHiddenControll
	btnSubidaSeqMin1 <- createButton vJogador1 2 12 hBoxControll hBoxHiddenControll
	btnSubidaSeqMax1 <- createButton vJogador1 2 13 hBoxControll hBoxHiddenControll
	btnSubidaSorte1 <- createButton vJogador1 2 14 hBoxControll hBoxHiddenControll
	btnSubidaYAN1 <- createButton vJogador1 2 15 hBoxControll hBoxHiddenControll
	btnSubidaTotal21 <- createInsensitiveButton table1 2 16
	
	btnLivreUm1 <- createButton vJogador1 3 1 hBoxControll hBoxHiddenControll
	btnLivreDois1 <- createButton vJogador1 3 2 hBoxControll hBoxHiddenControll
	btnLivreTres1 <- createButton vJogador1 3 3 hBoxControll hBoxHiddenControll
	btnLivreQuatro1 <- createButton vJogador1 3 4 hBoxControll hBoxHiddenControll
	btnLivreCinco1 <- createButton vJogador1 3 5 hBoxControll hBoxHiddenControll
	btnLivreSeis1 <- createButton vJogador1 3 6 hBoxControll hBoxHiddenControll
	btnLivreBonus1 <- createInsensitiveButton table1 3 7
	btnLivreTotal11 <- createInsensitiveButton table1 3 8
	btnLivreTrinca1 <- createButton vJogador1 3 9 hBoxControll hBoxHiddenControll
	btnLivreQuadra1 <- createButton vJogador1 3 10 hBoxControll hBoxHiddenControll
	btnLivreFull1 <- createButton vJogador1 3 11 hBoxControll hBoxHiddenControll
	btnLivreSeqMin1 <- createButton vJogador1 3 12 hBoxControll hBoxHiddenControll
	btnLivreSeqMax1 <- createButton vJogador1 3 13 hBoxControll hBoxHiddenControll
	btnLivreSorte1 <- createButton vJogador1 3 14 hBoxControll hBoxHiddenControll
	btnLivreYAN1 <- createButton vJogador1 3 15 hBoxControll hBoxHiddenControll
	btnLivreTotal21 <- createInsensitiveButton table1 3 16
	
	btnSecoUm1 <- createButton vJogador1 4 1 hBoxControll hBoxHiddenControll
	btnSecoDois1 <- createButton vJogador1 4 2 hBoxControll hBoxHiddenControll
	btnSecoTres1 <- createButton vJogador1 4 3 hBoxControll hBoxHiddenControll
	btnSecoQuatro1 <- createButton vJogador1 4 4 hBoxControll hBoxHiddenControll
	btnSecoCinco1 <- createButton vJogador1 4 5 hBoxControll hBoxHiddenControll
	btnSecoSeis1 <- createButton vJogador1 4 6 hBoxControll hBoxHiddenControll
	btnSecoBonus1 <- createInsensitiveButton table1 4 7
	btnSecoTotal11 <- createInsensitiveButton table1 4 8
	btnSecoTrinca1 <- createButton vJogador1 4 9 hBoxControll hBoxHiddenControll
	btnSecoQuadra1 <- createButton vJogador1 4 10 hBoxControll hBoxHiddenControll
	btnSecoFull1 <- createButton vJogador1 4 11 hBoxControll hBoxHiddenControll
	btnSecoSeqMin1 <- createButton vJogador1 4 12 hBoxControll hBoxHiddenControll
	btnSecoSeqMax1 <- createButton vJogador1 4 13 hBoxControll hBoxHiddenControll
	btnSecoSorte1 <- createButton vJogador1 4 14 hBoxControll hBoxHiddenControll
	btnSecoYAN1 <- createButton vJogador1 4 15 hBoxControll hBoxHiddenControll
	btnSecoTotal21 <- createInsensitiveButton table1 4 16
	
	btnTotal1 <- createButtonContainer hTotal1
	buttonSetRelief btnTotal1 ReliefNone
	widgetSetSensitivity btnTotal1 False 
	widgetSetSizeRequest btnTotal1 (-1) 25
		
	-- Tabela 2
	lblJogador2 <- createLabel table2 0 0 "Jogador2"
	lblSubida2 <- createLabel table2 1 0 "↓"
	lblDescida2 <- createLabel table2 2 0 "↑"
	lblLivre2 <- createLabel table2 3 0 "L"
	lblSeco2 <- createLabel table2 4 0 "S"
	lblUm2 <- createLabel table2 0 1 "1 (≥ 2)"
	lblDois2 <- createLabel table2 0 2 "2 (≥ 4)"
	lblTres2 <- createLabel table2 0 3 "3 (≥ 9)"
	lblQuatro2 <- createLabel table2 0 4 "4 (≥ 12)"
	lblCinco2 <- createLabel table2 0 5 "5 (≥ 15)"
	lblSeis2 <- createLabel table2 0 6 "6 (≥ 18)"
	lblBonus2 <- createLabel table2 0 7 "Bonus"
	lblTotal12 <- createLabel table2 0 8 "Total 1"
	lblTrinca2 <- createLabel table2 0 9 "Trinca"
	lblQuadra2 <- createLabel table2 0 10 "Quadra"
	lblFull2 <- createLabel table2 0 11 "Full House"
	lblSeqMin2 <- createLabel table2 0 12 "Sequencia -"
	lblSeqMax2 <- createLabel table2 0 13 "Sequencia +"
	lblSorte2 <- createLabel table2 0 14 "Sorte"
	lblYAN2 <- createLabel table2 0 15 "YAN"
	lblTotal22 <- createLabel table2 0 16 "Total 2"
	
	lblTotal2 <- createLabelContainer hTotal2 "Total Geral"
	 
	
	btnDescidaUm2 <- createButton vJogador2 1 1 hBoxControll hBoxHiddenControll
	btnDescidaDois2 <- createButton vJogador2 1 2 hBoxControll hBoxHiddenControll
	btnDescidaTres2 <- createButton vJogador2 1 3 hBoxControll hBoxHiddenControll
	btnDescidaQuatro2 <- createButton vJogador2 1 4 hBoxControll hBoxHiddenControll
	btnDescidaCinco2 <- createButton vJogador2 1 5 hBoxControll hBoxHiddenControll
	btnDescidaSeis2 <- createButton vJogador2 1 6 hBoxControll hBoxHiddenControll
	btnDescidaBonus2 <- createInsensitiveButton table2 1 7
	btnDescidaTotal12 <- createInsensitiveButton table2 1 8
	btnDescidaTrinca2 <- createButton vJogador2 1 9 hBoxControll hBoxHiddenControll
	btnDescidaQuadra2 <- createButton vJogador2 1 10 hBoxControll hBoxHiddenControll
	btnDescidaFull2 <- createButton vJogador2 1 11 hBoxControll hBoxHiddenControll
	btnDescidaSeqMin2 <- createButton vJogador2 1 12 hBoxControll hBoxHiddenControll
	btnDescidaSeqMax2 <- createButton vJogador2 1 13 hBoxControll hBoxHiddenControll
	btnDescidaSorte2 <- createButton vJogador2 1 14 hBoxControll hBoxHiddenControll
	btnDescidaYAN2 <- createButton vJogador2 1 15 hBoxControll hBoxHiddenControll
	btnDescidaTotal22 <- createInsensitiveButton table2 1 16
	
	btnSubidaUm2 <- createButton vJogador2 2 1 hBoxControll hBoxHiddenControll
	btnSubidaDois2 <- createButton vJogador2 2 2 hBoxControll hBoxHiddenControll
	btnSubidaTres2 <- createButton vJogador2 2 3 hBoxControll hBoxHiddenControll
	btnSubidaQuatro2 <- createButton vJogador2 2 4 hBoxControll hBoxHiddenControll
	btnSubidaCinco2 <- createButton vJogador2 2 5 hBoxControll hBoxHiddenControll
	btnSubidaSeis2 <- createButton vJogador2 2 6 hBoxControll hBoxHiddenControll
	btnSubidaBonus2 <- createInsensitiveButton table2 2 7
	btnSubidaTotal12 <- createInsensitiveButton table2 2 8
	btnSubidaTrinca2 <- createButton vJogador2 2 9 hBoxControll hBoxHiddenControll
	btnSubidaQuadra2 <- createButton vJogador2 2 10 hBoxControll hBoxHiddenControll
	btnSubidaFull2 <- createButton vJogador2 2 11 hBoxControll hBoxHiddenControll
	btnSubidaSeqMin2 <- createButton vJogador2 2 12 hBoxControll hBoxHiddenControll
	btnSubidaSeqMax2 <- createButton vJogador2 2 13 hBoxControll hBoxHiddenControll
	btnSubidaSorte2 <- createButton vJogador2 2 14 hBoxControll hBoxHiddenControll
	btnSubidaYAN2 <- createButton vJogador2 2 15 hBoxControll hBoxHiddenControll
	btnSubidaTotal22 <- createInsensitiveButton table2 2 16
	
	btnLivreUm2 <- createButton vJogador2 3 1 hBoxControll hBoxHiddenControll
	btnLivreDois2 <- createButton vJogador2 3 2 hBoxControll hBoxHiddenControll
	btnLivreTres2 <- createButton vJogador2 3 3 hBoxControll hBoxHiddenControll
	btnLivreQuatro2 <- createButton vJogador2 3 4 hBoxControll hBoxHiddenControll
	btnLivreCinco2 <- createButton vJogador2 3 5 hBoxControll hBoxHiddenControll
	btnLivreSeis2 <- createButton vJogador2 3 6 hBoxControll hBoxHiddenControll
	btnLivreBonus2 <- createInsensitiveButton table2 3 7
	btnLivreTotal12 <- createInsensitiveButton table2 3 8
	btnLivreTrinca2 <- createButton vJogador2 3 9 hBoxControll hBoxHiddenControll
	btnLivreQuadra2 <- createButton vJogador2 3 10 hBoxControll hBoxHiddenControll
	btnLivreFull2 <- createButton vJogador2 3 11 hBoxControll hBoxHiddenControll
	btnLivreSeqMin2 <- createButton vJogador2 3 12 hBoxControll hBoxHiddenControll
	btnLivreSeqMax2 <- createButton vJogador2 3 13 hBoxControll hBoxHiddenControll
	btnLivreSorte2 <- createButton vJogador2 3 14 hBoxControll hBoxHiddenControll
	btnLivreYAN2 <- createButton vJogador2 3 15 hBoxControll hBoxHiddenControll
	btnLivreTotal22 <- createInsensitiveButton table2 3 16
	
	btnSecoUm2 <- createButton vJogador2 4 1 hBoxControll hBoxHiddenControll
	btnSecoDois2 <- createButton vJogador2 4 2 hBoxControll hBoxHiddenControll
	btnSecoTres2 <- createButton vJogador2 4 3 hBoxControll hBoxHiddenControll
	btnSecoQuatro2 <- createButton vJogador2 4 4 hBoxControll hBoxHiddenControll
	btnSecoCinco2 <- createButton vJogador2 4 5 hBoxControll hBoxHiddenControll
	btnSecoSeis2 <- createButton vJogador2 4 6 hBoxControll hBoxHiddenControll
	btnSecoBonus2 <- createInsensitiveButton table2 4 7
	btnSecoTotal12 <- createInsensitiveButton table2 4 8
	btnSecoTrinca2 <- createButton vJogador2 4 9 hBoxControll hBoxHiddenControll
	btnSecoQuadra2 <- createButton vJogador2 4 10 hBoxControll hBoxHiddenControll
	btnSecoFull2 <- createButton vJogador2 4 11 hBoxControll hBoxHiddenControll
	btnSecoSeqMin2 <- createButton vJogador2 4 12 hBoxControll hBoxHiddenControll
	btnSecoSeqMax2 <- createButton vJogador2 4 13 hBoxControll hBoxHiddenControll
	btnSecoSorte2 <- createButton vJogador2 4 14 hBoxControll hBoxHiddenControll
	btnSecoYAN2 <- createButton vJogador2 4 15 hBoxControll hBoxHiddenControll
	btnSecoTotal22 <- createInsensitiveButton table2 4 16
	
	btnTotal2 <- createButtonContainer hTotal2
	buttonSetRelief btnTotal2 ReliefNone
	widgetSetSensitivity btnTotal2 False
	widgetSetSizeRequest btnTotal2 (-1) 25
	
	-- controll
	btnDado1 <- createButtonImageContainer "../resources/face0.png" hBoxControll
	btnDado2 <- createButtonImageContainer "../resources/face0.png" hBoxControll
	btnDado3 <- createButtonImageContainer "../resources/face0.png" hBoxControll
	btnDado4 <- createButtonImageContainer "../resources/face0.png" hBoxControll
	btnDado5 <- createButtonImageContainer "../resources/face0.png" hBoxControll
	
	buttonDadoAddAction btnDado1 1 hBoxHiddenControll
	buttonDadoAddAction btnDado2 2 hBoxHiddenControll
	buttonDadoAddAction btnDado3 3 hBoxHiddenControll
	buttonDadoAddAction btnDado4 4 hBoxHiddenControll
	buttonDadoAddAction btnDado5 5 hBoxHiddenControll
	
	btnPlay <- createButtonContainer hBoxControll
	buttonSetLabel btnPlay "Lançar Dados"
	
	onClicked btnPlay $ do
		
		jogador <- hiddenControllGetJogador hBoxHiddenControll
		
		tabela <- if jogador == 1
			then tableGetTabela table1
			else tableGetTabela table2
			
		dados <- hiddenControllGetDados hBoxHiddenControll
		changes <- hiddenControllGetChanges hBoxHiddenControll
		novosDados <- lancarDados dados changes
		hiddenControllSetDados hBoxHiddenControll novosDados
		hiddenControllSetChanges hBoxHiddenControll [0, 0, 0, 0, 0]
		controllSetDados hBoxControll novosDados
		hiddenControllIncrementJogada hBoxHiddenControll
		let maxJogadas = if (isTabelaDisponivelSemSeco tabela) then 2 else 0
		setPlaySensitivity btnPlay hBoxHiddenControll maxJogadas
		jogador <- hiddenControllGetJogador hBoxHiddenControll
		
		if jogador == 1
			then do
				tableSetTabelaDisponivel table2 tabelaIndisponivel
				jogada <- hiddenControllGetJogada hBoxHiddenControll
				let tabelaDisponivel = gerarTabelaDisponivel tabela jogada 
				tableSetTabelaDisponivel table1 tabelaDisponivel
				
				return ()
			else do
				tableSetTabelaDisponivel table1 tabelaIndisponivel
				jogada <- hiddenControllGetJogada hBoxHiddenControll
				let tabelaDisponivel = gerarTabelaDisponivel tabela jogada 
				tableSetTabelaDisponivel table2 tabelaDisponivel
				
				return ()
		
		return ()
		
	-- hidden controll
	lblDado1 <- createLabelContainer hBoxHiddenControll "0"
	lblDado1Change <- createLabelContainer hBoxHiddenControll "1"
	
	lblDado2 <- createLabelContainer hBoxHiddenControll "0"
	lblDado2Change <- createLabelContainer hBoxHiddenControll "1"
	
	lblDado3 <- createLabelContainer hBoxHiddenControll "0"
	lblDado3Change <- createLabelContainer hBoxHiddenControll "1"
	
	lblDado4 <- createLabelContainer hBoxHiddenControll "0"
	lblDado4Change <- createLabelContainer hBoxHiddenControll "1"
	
	lblDado5 <- createLabelContainer hBoxHiddenControll "0"
	lblDado5Change <- createLabelContainer hBoxHiddenControll "1"
	
	lblJogador <- createLabelContainer hBoxHiddenControll "1"
	lblJogada <- createLabelContainer hBoxHiddenControll "0"
	
	set window [ containerBorderWidth := 0, containerChild := vBox1 ]
	
	tableSetTabelaDisponivel table1 tabelaIndisponivel
	tableSetTabelaDisponivel table2 tabelaIndisponivel
	resetGame vJogador1 vJogador2 table1 table2 hBoxControll hBoxHiddenControll
	
	onDestroy window mainQuit
	widgetShowAll window
	
	mainGUI
	
createMenuBar descr
    = do bar <- menuBarNew
         mapM_ (createMenu bar) descr
         return bar
    where
      createMenu bar (name,items)
          = do menu <- menuNew
               item <- menuItemNewWithLabelOrMnemonic name
               menuItemSetSubmenu item menu
               menuShellAppend bar item
               mapM_ (createMenuItem menu) items
      createMenuItem menu (name,action)
          = do item <- menuItemNewWithLabelOrMnemonic name
               menuShellAppend menu item
               case action of
                 Just act -> onActivateLeaf item act
                 Nothing  -> onActivateLeaf item (return ())
      menuItemNewWithLabelOrMnemonic name
          | elem '_' name = menuItemNewWithMnemonic name
          | otherwise     = menuItemNewWithLabel name

menuBarDescr vJogador1 vJogador2 table1 table2 control hiddenControl
    = [ ("_Jogo", [ ("_Novo", Just (resetGame vJogador1 vJogador2 table1 table2 control hiddenControl))
                  , ("_Sair", Just mainQuit)
                  ]
        )
      ]
      
resetGame vJogador1 vJogador2 table1 table2 control hiddenControl = do
	let tabelaSomatorio = gerarSomatorios tabelaLimpa

	tableSetTabela table1 tabelaLimpa
	tableSetTabela table2 tabelaLimpa
	controllSetDados control [0,0,0,0,0]
	tableSetTabelaSomatorio vJogador1 tabelaSomatorio
	tableSetTabelaSomatorio vJogador2 tabelaSomatorio
	hiddenControllSetDados hiddenControl [0,0,0,0,0]
	hiddenControllSetChanges hiddenControl [1,1,1,1,1]
	hiddenControllSetJogador hiddenControl 1
	hiddenControllSetJogada hiddenControl 0

createLabel table x y text = do
	label <- labelNew Nothing
	labelSetText label text
	tableAttachDefaults table label x (x+1) y (y+1)
	return label

--tableGetTableJogador :: [Widget] -> Table
--tableGetTableJogador [tabela,_] = castToTable tabela

createButton vBox x y boxControll hiddenControll = do
	vBoxElems <- containerGetChildren vBox
	let table = castToTable (head vBoxElems)
	
	button <- buttonNew
	buttonSetFocusOnClick button False
	tableAttachDefaults table button x (x+1) y (y+1)
	widgetSetSizeRequest button (-1) 25
	widgetSetCanFocus button False
	
	let categoria = case x of
		1 -> DESCIDA
		2 -> SUBIDA
		3 -> LIVRE
		4 -> SECO
		
	let combinacao = case y of
		1 -> UM
		2 -> DOIS
		3 -> TRES
		4 -> QUATRO
		5 -> CINCO
		6 -> SEIS
		9 -> TRINCA
		10 -> QUADRA
		11 -> FULL
		12 -> SEQMIN
		13 -> SEQMAX
		14 -> SORTE
		15 -> YAN
	
	buttonTableAddAction button vBox categoria combinacao boxControll hiddenControll
	
	return button
	
createInsensitiveButton table x y = do
	button <- buttonNew
	buttonSetFocusOnClick button False
	buttonSetRelief button ReliefNone
	buttonSetLabel button "0"
	tableAttachDefaults table button x (x+1) y (y+1)
	widgetSetSizeRequest button (-1) 25
	widgetSetCanFocus button False
	widgetSetSensitivity button False
	return button	
	
createButtonContainer container = do
	button <- buttonNew
	buttonSetFocusOnClick button False
	containerAdd container button
	widgetSetCanFocus button False
	return button

createLabelContainer container string = do
	label <- labelNew Nothing
	labelSetText label string
	containerAdd container label
	return label

createButtonImageContainer imagePath container = do
	button <- buttonNew
	buttonSetFocusOnClick button False
	image <- imageNewFromFile imagePath
	buttonSetImage button image
	containerAdd container button
	buttonSetRelief button ReliefNone
	widgetSetSizeRequest button (-1) 90
	widgetSetCanFocus button False
	return button
	
buttonTableAddAction button vBox categoria combinacao boxControll hiddenControll = do
	onClicked button $ do
		
		vBoxElems <- containerGetChildren vBox
		let table = castToTable (head vBoxElems)
		
		jogada <- hiddenControllGetJogada hiddenControll
		tabela <- tableGetTabela table
		dados <- hiddenControllGetDados hiddenControll
		let novaTabela = marcar tabela dados jogada categoria combinacao
		let tabelaSomatorio = gerarSomatorios novaTabela
		tableSetTabela table novaTabela
		tableSetTabelaSomatorio vBox tabelaSomatorio
		hiddenControllToogleJogador hiddenControll
		hiddenControllResetJogada hiddenControll
		controllSetDados boxControll [0,0,0,0,0]
		hiddenControllSetDados hiddenControll [0,0,0,0,0]
		hiddenControllSetChanges hiddenControll [1,1,1,1,1]
		
		btnPlay <- buttonGetPlay boxControll
		setPlaySensitivity btnPlay hiddenControll 2
		tableSetTabelaDisponivel table tabelaIndisponivel
		
		return ()

buttonDadoAddAction button dadoId hBoxHiddenControll = do
	onClicked button $ do
		change <- hiddenControllGetChange hBoxHiddenControll dadoId
		if change == 0
			then do
				buttonSetDado button 0
				hiddenControllSetChange hBoxHiddenControll 1 dadoId
				return ()
			else do
				dado <- hiddenControllGetDado hBoxHiddenControll dadoId
				
				if dado /= 0
					then do 
						buttonSetDado button dado
						hiddenControllSetChange hBoxHiddenControll 0 dadoId
						return ()
					else do
						return ()
						
tableSetTabelaDisponivel :: Table -> Tabela -> IO ()
tableSetTabelaDisponivel table [(DESCIDA, columnDescida),(SUBIDA, columnSubida),
						(LIVRE, columnLivre),(SECO, columnSeco)] = do
	
	tableSetColumnDisponivel table DESCIDA columnDescida
	tableSetColumnDisponivel table SUBIDA columnSubida
	tableSetColumnDisponivel table LIVRE columnLivre
	tableSetColumnDisponivel table SECO columnSeco
	
	return () 

tableSetColumnDisponivel :: Table -> Categoria -> Coluna -> IO ()
tableSetColumnDisponivel table categoria [(UM, um), (DOIS, dois), (TRES, tres),
		(QUATRO, quatro), (CINCO, cinco), (SEIS, seis),	(TRINCA, trinca),
		(QUADRA, quadra), (FULL, full), (SEQMIN, seqmin), (SEQMAX, seqmax), 
		(SORTE, sorte), (YAN, yan)] = do
	cells <- containerGetChildren table
	
	let columnIndex = case categoria of
		DESCIDA -> 3
		SUBIDA -> 2
		LIVRE -> 1
		SECO -> 0
	
	cellsSetCellDisponivel cells (15  + columnIndex * 16) um 
	cellsSetCellDisponivel cells (14 + columnIndex * 16) dois
	cellsSetCellDisponivel cells (13 + columnIndex * 16) tres
	cellsSetCellDisponivel cells (12 + columnIndex * 16) quatro
	cellsSetCellDisponivel cells (11 + columnIndex * 16) cinco
	cellsSetCellDisponivel cells (10 + columnIndex * 16) seis
	cellsSetCellDisponivel cells (7 + columnIndex * 16) trinca
	cellsSetCellDisponivel cells (6 + columnIndex * 16) quadra
	cellsSetCellDisponivel cells (5 + columnIndex * 16) full
	cellsSetCellDisponivel cells (4 + columnIndex * 16) seqmin
	cellsSetCellDisponivel cells (3 + columnIndex * 16) seqmax
	cellsSetCellDisponivel cells (2 + columnIndex * 16) sorte
	cellsSetCellDisponivel cells (1 + columnIndex * 16) yan
	
	return ()
	
cellsSetCellDisponivel :: [Widget] -> Int -> Int -> IO ()
cellsSetCellDisponivel [] _ _ = error "Index out of bounds"
cellsSetCellDisponivel (a:as) 0 isDisponivel = do
	
	if isDisponivel == 0
		then do
			widgetSetSensitivity a False
			return ()
		else do
			widgetSetSensitivity a True
			return ()
			
	return ()
cellsSetCellDisponivel (a:as) x isDisponivel = cellsSetCellDisponivel as (x - 1) isDisponivel	


tableSetTabelaSomatorio :: VBox -> Somatorios -> IO ()
tableSetTabelaSomatorio vbox (somatorioTotal, [(DESCIDA, columnSomatorioDescida),
			(SUBIDA, columnSomatorioSubida), (LIVRE, columnSomatorioLivre),
			(SECO, columnSomatorioSeco)]) = do
	
	elems <- containerGetChildren vbox
	let table = castToTable (head elems)
	tableSetColumnSomatorio table DESCIDA columnSomatorioDescida
	tableSetColumnSomatorio table SUBIDA columnSomatorioSubida
	tableSetColumnSomatorio table LIVRE columnSomatorioLivre
	tableSetColumnSomatorio table SECO columnSomatorioSeco
	
	let hTotal = castToHBox (last elems)
	totalElems <- containerGetChildren hTotal
	let btnTotal = castToButton (last totalElems)
	buttonSetLabel btnTotal (intToString somatorioTotal)
	
	return ()
						
tableSetColumnSomatorio :: Table -> Categoria -> ColunaSomatorio -> IO ()
tableSetColumnSomatorio table categoria [(BONUS, bonus), (TOTAL1, total1),
	(TOTAL2, total2)] = do

	cells <- containerGetChildren table
	
	let columnIndex = case categoria of
		DESCIDA -> 3
		SUBIDA -> 2
		LIVRE -> 1
		SECO -> 0
		
	cellsSetCellValue cells (0  + columnIndex * 16) total2
	cellsSetCellValue cells (8 + columnIndex * 16) total1
	cellsSetCellValue cells (9 + columnIndex * 16) bonus
	
	return ()
			
{---
 - tableGetTabela(table)
 -   table: tabela com as combinações e categorias de um dado jogador
 - retorna a tabela com os valores de todas combinações e categorias para um
 - dado jogador.
 -
 - Função que avalia todas as combinações de todas as categorias para um dado
 - jogador, retornando sua tabela relativa.
 --}

tableGetTabela :: Table -> IO Tabela
tableGetTabela table = do

	columnDescida <- (tableGetColumn table DESCIDA)
	columnSubida <- (tableGetColumn table SUBIDA)
	columnLivre <- (tableGetColumn table LIVRE)
	columnSeco <- (tableGetColumn table SECO)
	
	let tabela = fazerTabela columnDescida columnSubida columnLivre columnSeco
			 
	return tabela

{---
 - tableSetTabela(table, tabela)
 -   table: tabela gráfica com as combinações e categorias de um dado jogador
 -   tabela: tabela lógica com as combinações e categorias de um dado jogador
 -
 - Função marca atualiza na tabela gráfica os valores da tabela lógica passada
 - como parâmetro.
 --}	
tableSetTabela :: Table -> Tabela -> IO ()
tableSetTabela table [(DESCIDA, columnDescida),(SUBIDA, columnSubida),
						(LIVRE, columnLivre),(SECO, columnSeco)] = do
	
	tableSetColumn table DESCIDA columnDescida
	tableSetColumn table SUBIDA columnSubida
	tableSetColumn table LIVRE columnLivre
	tableSetColumn table SECO columnSeco
	
	return ()
		
{---
 - tableGetColumn(table, categoria)
 -   table: tabela com as combinações e categorias de um dado jogador
 -   categoria: categoria a ser selecionada na tabela
 - retorna a coluna de combinações relativa à categoria passada.
 -
 - Função que procura dentre os elementos da table passada, aquelas que
 - representam a categoria também passada como parâmetro, retornando uma coluna
 - relativa a essa categoria.
 --}
tableGetColumn :: Table -> Categoria -> IO Coluna
tableGetColumn table categoria = do
	cells <- containerGetChildren table
	
	let columnIndex = case categoria of
		DESCIDA -> 3
		SUBIDA -> 2
		LIVRE -> 1
		SECO -> 0
		
	um <- cellsGetCellValue cells (15  + columnIndex * 16)
	dois <- cellsGetCellValue cells (14 + columnIndex * 16)
	tres <- cellsGetCellValue cells (13 + columnIndex * 16)
	quatro <- cellsGetCellValue cells (12 + columnIndex * 16)
	cinco <- cellsGetCellValue cells (11 + columnIndex * 16)
	seis <- cellsGetCellValue cells (10 + columnIndex * 16)
	trinca <- cellsGetCellValue cells (7 + columnIndex * 16)
	quadra <- cellsGetCellValue cells (6 + columnIndex * 16)
	full <- cellsGetCellValue cells (5 + columnIndex * 16)
	seqmin <- cellsGetCellValue cells (4 + columnIndex * 16)
	seqmax <- cellsGetCellValue cells (3 + columnIndex * 16)
	sorte <- cellsGetCellValue cells (2 + columnIndex * 16)
	yan <- cellsGetCellValue cells (1 + columnIndex * 16)
	
	let column = fazerColuna um dois tres quatro cinco seis trinca quadra full
					seqmin seqmax sorte yan
	
	return column

{---
 - tableSetColumn(table, categoria, coluna)
 -   table: tabela gráfica com as combinações e categorias de um dado jogador
 -   categoria: categoria a ser atualizada na tabela
 -   coluna: coluna com as combinações a serem atualizadas na tabela
 -
 - Função que procura dentre os elementos da table passada, aquelas que
 - representam a categoria também passada como parâmetro, atualizando os valores
 - de todas suas combinações de acordo com a coluna passada como parâmetro.
 --}	
tableSetColumn :: Table -> Categoria -> Coluna -> IO ()
tableSetColumn table categoria [(UM, um), (DOIS, dois), (TRES, tres),
		(QUATRO, quatro), (CINCO, cinco), (SEIS, seis),	(TRINCA, trinca),
		(QUADRA, quadra), (FULL, full), (SEQMIN, seqmin), (SEQMAX, seqmax), 
		(SORTE, sorte), (YAN, yan)] = do
	cells <- containerGetChildren table
	
	let columnIndex = case categoria of
		DESCIDA -> 3
		SUBIDA -> 2
		LIVRE -> 1
		SECO -> 0
	
	cellsSetCellValue cells (15  + columnIndex * 16) um 
	cellsSetCellValue cells (14 + columnIndex * 16) dois
	cellsSetCellValue cells (13 + columnIndex * 16) tres
	cellsSetCellValue cells (12 + columnIndex * 16) quatro
	cellsSetCellValue cells (11 + columnIndex * 16) cinco
	cellsSetCellValue cells (10 + columnIndex * 16) seis
	cellsSetCellValue cells (7 + columnIndex * 16) trinca
	cellsSetCellValue cells (6 + columnIndex * 16) quadra
	cellsSetCellValue cells (5 + columnIndex * 16) full
	cellsSetCellValue cells (4 + columnIndex * 16) seqmin
	cellsSetCellValue cells (3 + columnIndex * 16) seqmax
	cellsSetCellValue cells (2 + columnIndex * 16) sorte
	cellsSetCellValue cells (1 + columnIndex * 16) yan
	
	return ()

{---
 - cellGetCellValue(cells, index)
 -   cells: conjunto de widgets pertencentes a uma Table
 -   index: indice do botão procurado
 - retorna o valor inteiro que representa o texto escrito no botão.
 -
 - Função que procura dentre os widgets de uma table um dado botão, convertendo
 - o texto do botão em inteiro, retornando esse valor.
 --}
cellsGetCellValue :: [Widget] -> Int -> IO Int
cellsGetCellValue [] _ = error "Index out of bounds"
cellsGetCellValue (a:as) 0 = do
	buttonLabel <- buttonGetLabel (castToButton a)
	let value = stringToInt buttonLabel
	return value
cellsGetCellValue (a:as) x = cellsGetCellValue as (x - 1)

{---
 - cellSetCellValue(cells, index, value)
 -   cells: conjunto de widgets pertencentes a uma Table
 -   index: indice do botão procurado
 -   value: valor a ser setado
 -
 - Função que procura dentre os widgets de uma table um dado botão, setando seu
 - novo valor de acordo com o valor passado como parâmetro.
 --}
cellsSetCellValue :: [Widget] -> Int -> Int -> IO ()
cellsSetCellValue [] _ _ = error "Index out of bounds"
cellsSetCellValue (a:as) 0 value = do
	let label = intToString value
	buttonLabel <- buttonSetLabel (castToButton a) label
	return ()
cellsSetCellValue (a:as) x value = cellsSetCellValue as (x - 1) value

{---
 - hiddenControllGetDados(hiddenControll)
 -   hiddenControll: HBox que contem controles ocutos do jogo como o valor dos
 -     dados, se algum dados será modificado e o jogador em questão.
 - retorna os valores atuais dos dados
 -
 - Função que procura dentre as labels do HBox aquelas que representam os
 - valores atuais dos dados e retorna esses valores.
 --}
hiddenControllGetDados :: HBox -> IO Dados
hiddenControllGetDados hiddenControll = do
	labels <- containerGetChildren hiddenControll
	dados <- labelsGetDados labels
	return dados

{---
 - labelsGetDados(labels)
 -   labels: Lista de labels com todas as informações contidas no hiddenControll
 - retorna os valores atuais dos dados.
 -
 - Função que procura dentre as labels do HBox aquelas que representam os
 - valores atuais dos dados e retorna esses valores.
 --}
labelsGetDados :: [Widget] -> IO Dados
labelsGetDados [lblD1,_,lblD2,_,lblD3,_,lblD4,_,lblD5,_,_,_] = do
	d1 <- labelGetText (castToLabel lblD1)
	d2 <- labelGetText (castToLabel lblD2)
	d3 <- labelGetText (castToLabel lblD3)
	d4 <- labelGetText (castToLabel lblD4)
	d5 <- labelGetText (castToLabel lblD5)
	
	let d1Value = stringToInt d1
	let d2Value = stringToInt d2
	let d3Value = stringToInt d3
	let d4Value = stringToInt d4
	let d5Value = stringToInt d5
	
	return [d1Value, d2Value, d3Value, d4Value, d5Value]

{---
 - hiddenControllSetDados(hiddenControll, dados)
 -   hiddenControll: HBox que contem controles ocutos do jogo como o valor dos
 -     dados, se algum dados será modificado e o jogador em questão.
 -   dados: valores dos dados a serem setados.
 -
 - Função que procura dentre as labels do HBox aquelas que representam os
 - valores atuais dos dados, setando nestas novos valores.
 --}
hiddenControllSetDados :: HBox -> Dados -> IO ()
hiddenControllSetDados hiddenControll dados = do
	labels <- containerGetChildren hiddenControll
	labelsSetDados labels dados
	return ()

{---
 - labelsSetDados(labels, dados)
 -   labels: Lista de labels com todas as informações contidas no hiddenControll
 -   dados: valores dos dados a serem setados.
 -
 - Função que procura dentre as labels do HBox aquelas que representam os
 - valores atuais dos dados, setando nestas novoas valores.
 --}
labelsSetDados :: [Widget] -> Dados -> IO ()
labelsSetDados [lblD1,_,lblD2,_,lblD3,_,lblD4,_,lblD5,_,_,_] [d1,d2,d3,d4,d5] = do

	let d1String = intToString d1
	let d2String = intToString d2
	let d3String = intToString d3
	let d4String = intToString d4
	let d5String = intToString d5
	
	labelSetText (castToLabel lblD1) d1String
	labelSetText (castToLabel lblD2) d2String
	labelSetText (castToLabel lblD3) d3String
	labelSetText (castToLabel lblD4) d4String
	labelSetText (castToLabel lblD5) d5String
	
	return ()

{---
 - hiddenControllGetChanges(hiddenControll)
 -   hiddenControll: HBox que contem controles ocutos do jogo como o valor dos
 -     dados, se algum dados será modificado e o jogador em questão.
 - retorna se cada dado pode ser modificado ou não.
 -
 - Função que procura dentre as labels do HBox aquelas que representam se os 
 - dados podem ser modificados ou não.
 --}	
hiddenControllGetChanges :: HBox -> IO [Int]
hiddenControllGetChanges hiddenControll = do
	labels <- containerGetChildren hiddenControll
	changes <- labelsGetChanges labels
	return changes

{---
 - labelsGetChanges(labels)
 -   labels: Lista de labels com todas as informações contidas no hiddenControll
 - retorna se cada dado pode ser modificado ou não.
 -
 - Função que procura dentre as labels do HBox aquelas que representam se os 
 - dados podem ser modificados ou não.
 --}	
labelsGetChanges :: [Widget] -> IO [Int]
labelsGetChanges [_,lblC1,_,lblC2,_,lblC3,_,lblC4,_,lblC5,_,_] = do
	c1 <- labelGetText (castToLabel lblC1)
	c2 <- labelGetText (castToLabel lblC2)
	c3 <- labelGetText (castToLabel lblC3)
	c4 <- labelGetText (castToLabel lblC4)
	c5 <- labelGetText (castToLabel lblC5)
	
	let c1Value = stringToInt c1
	let c2Value = stringToInt c2
	let c3Value = stringToInt c3
	let c4Value = stringToInt c4
	let c5Value = stringToInt c5
	
	return [c1Value, c2Value, c3Value, c4Value, c5Value]
	
hiddenControllGetDado :: HBox -> Int -> IO Int
hiddenControllGetDado hiddenControll dadoId = do
	
	labels <- containerGetChildren hiddenControll
	dado <- labelsGetDado labels dadoId
	
	return dado
	
labelsGetDado :: [Widget] -> Int -> IO Int
labelsGetDado [lblD1,_,lblD2,_,lblD3,_,lblD4,_,lblD5,_,_,_] dadoId = do
	
	let label = case dadoId of
		1 -> (castToLabel lblD1)
		2 -> (castToLabel lblD2)
		3 -> (castToLabel lblD3)
		4 -> (castToLabel lblD4)
		5 -> (castToLabel lblD5)
	
	labelText <- labelGetText label
	let dado = stringToInt labelText
	
	return dado

hiddenControllSetChanges :: HBox -> [Int] -> IO ()
hiddenControllSetChanges hiddenControll changes = do
	labels <- containerGetChildren hiddenControll
	labelsSetChanges labels changes
	return ()
	
labelsSetChanges :: [Widget] -> [Int] -> IO ()
labelsSetChanges [_,lblC1,_,lblC2,_,lblC3,_,lblC4,_,lblC5,_,_]
				 [c1, c2, c3, c4, c5] = do
	
	let c1String = intToString c1
	let c2String = intToString c2
	let c3String = intToString c3
	let c4String = intToString c4
	let c5String = intToString c5
	
	labelSetText (castToLabel lblC1) c1String
	labelSetText (castToLabel lblC2) c2String
	labelSetText (castToLabel lblC3) c3String
	labelSetText (castToLabel lblC4) c4String
	labelSetText (castToLabel lblC5) c5String
	
	return ()
	
controllSetDados :: HBox -> Dados -> IO ()
controllSetDados controll dados = do
	buttons <- containerGetChildren controll
	buttonsSetDados buttons dados
	return ()
	
buttonsSetDados :: [Widget] -> Dados -> IO ()
buttonsSetDados [btnDado1, btnDado2, btnDado3, btnDado4, btnDado5, _]
				[d1, d2, d3, d4, d5] = do
				
	image1 <- imageNewFromFile (getImagePath d1)
	image2 <- imageNewFromFile (getImagePath d2)
	image3 <- imageNewFromFile (getImagePath d3)
	image4 <- imageNewFromFile (getImagePath d4)
	image5 <- imageNewFromFile (getImagePath d5)
	
	buttonSetImage (castToButton btnDado1) image1
	buttonSetImage (castToButton btnDado2) image2
	buttonSetImage (castToButton btnDado3) image3
	buttonSetImage (castToButton btnDado4) image4
	buttonSetImage (castToButton btnDado5) image5
	
	return ()
	
buttonSetDado :: Button -> Int -> IO ()
buttonSetDado button d = do

	image <- imageNewFromFile (getImagePath d)
	buttonSetImage button image
	
	return ()

hiddenControllGetChange :: HBox -> Int -> IO Int
hiddenControllGetChange hiddenControll dadoId = do
	
	labels <- containerGetChildren hiddenControll
	change <- labelsGetChange labels dadoId
	
	return change

labelsGetChange :: [Widget] -> Int -> IO Int
labelsGetChange [_, lblC1, _, lblC2, _, lblC3, _, lblC4, _, lblC5, _, _] 
				dadoId = do
	
	let label = case dadoId of
		1 -> (castToLabel lblC1)
		2 -> (castToLabel lblC2)
		3 -> (castToLabel lblC3)
		4 -> (castToLabel lblC4)
		5 -> (castToLabel lblC5)
	
	labelText <- labelGetText label
	let change = stringToInt labelText
	
	return change


hiddenControllSetChange :: HBox -> Int -> Int -> IO ()
hiddenControllSetChange hiddenControll change dadoId = do
	
	labels <- containerGetChildren hiddenControll
	labelsSetChange labels change dadoId
	
	return ()
	
labelsSetChange :: [Widget] -> Int -> Int -> IO ()
labelsSetChange [_, lblC1, _, lblC2, _, lblC3, _, lblC4, _, lblC5, _, _] change
				dadoId = do
	
	let label = case dadoId of
		1 -> (castToLabel lblC1)
		2 -> (castToLabel lblC2)
		3 -> (castToLabel lblC3)
		4 -> (castToLabel lblC4)
		5 -> (castToLabel lblC5)
	
	let labelText = intToString change
	labelSetText label labelText
	
	return ()
	
hiddenControllGetJogada :: HBox -> IO Int
hiddenControllGetJogada hiddenControll = do
	
	labels <- containerGetChildren hiddenControll
	jogada <- labelsGetJogada labels
	
	return jogada
	
labelsGetJogada :: [Widget] -> IO Int
labelsGetJogada [_, _, _, _, _, _, _, _, _, _, _, lblJogada] = do
	 	
	labelText <- labelGetText (castToLabel lblJogada)
	let jogada = stringToInt labelText
	
	return jogada
	
hiddenControllSetJogada :: HBox-> Int -> IO ()
hiddenControllSetJogada controll value = do
	labels <- containerGetChildren controll
	let lblJogada = labelGetLblJogada labels
	labelSetLabel lblJogada (intToString value)
	
	return ()
	
labelGetLblJogada :: [Widget] -> Label
labelGetLblJogada [_, _, _, _, _, _, _, _, _, _, _, lblJogada] = castToLabel lblJogada 

hiddenControllIncrementJogada :: HBox -> IO ()
hiddenControllIncrementJogada controll = do
	current <- hiddenControllGetJogada controll
	hiddenControllSetJogada controll (current + 1)
	return ()
	
hiddenControllResetJogada :: HBox -> IO ()
hiddenControllResetJogada controll = do
	hiddenControllSetJogada controll 0
	return ()
	
buttonGetPlay :: HBox -> IO Button
buttonGetPlay hbox = do
	buttons <- containerGetChildren hbox
	return (buttonGetBtnPlay buttons)
	
buttonGetBtnPlay :: [Widget] -> Button
buttonGetBtnPlay [_,_,_,_,_,btnPlay] = castToButton btnPlay

	
setPlaySensitivity :: Button -> HBox -> Int -> IO ()
setPlaySensitivity btnPlay control limit = do
	jogadas <- hiddenControllGetJogada control
	let enabled = if jogadas <= limit then True else False
	widgetSetSensitivity btnPlay enabled
	return () 
	
hiddenControllGetJogador :: HBox -> IO Int
hiddenControllGetJogador hiddenControll = do
	
	labels <- containerGetChildren hiddenControll
	jogador <- labelsGetJogador labels
	
	return 	jogador
	
labelsGetJogador :: [Widget] -> IO Int
labelsGetJogador [_,_,_,_,_,_,_,_,_,_,lblJogador,_] = do
	
	jogadorString <- labelGetText (castToLabel lblJogador)
	let jogador = stringToInt jogadorString 
	    
	return jogador
	
hiddenControllSetJogador :: HBox -> Int -> IO ()
hiddenControllSetJogador hiddenControll jogador = do
	
	labels <- containerGetChildren hiddenControll
	labelsSetJogador labels jogador
	
	return ()
	
labelsSetJogador :: [Widget] -> Int -> IO ()
labelsSetJogador [_, _, _, _, _, _, _, _, _, _, lblJogador, _] jogador = do

	let jogadorString = intToString jogador
	labelSetText (castToLabel lblJogador) jogadorString
    
	return ()
		
	
hiddenControllToogleJogador :: HBox -> IO ()
hiddenControllToogleJogador hiddenControl = do

	labels <- containerGetChildren hiddenControl
	jogador <- labelsToogleJogador labels
    
	return ()

labelsToogleJogador :: [Widget] -> IO ()
labelsToogleJogador [_, _, _, _, _, _, _, _, _, _, lblJogador, _] = do

	jogador <- labelGetText (castToLabel lblJogador)
	let novoJogador = if jogador == "1"
		then "2"
		else "1"
    
	labelSetText (castToLabel lblJogador) novoJogador
    
	return ()
	
getImagePath :: Int -> String
getImagePath 0 = "../resources/face0.png" 
getImagePath 1 = "../resources/face1.png"
getImagePath 2 = "../resources/face2.png"
getImagePath 3 = "../resources/face3.png"
getImagePath 4 = "../resources/face4.png"
getImagePath 5 = "../resources/face5.png"
getImagePath 6 = "../resources/face6.png"
